home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 526-550 / disk_541 / steal / src / print.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  25KB  |  741 lines
  1. /****************************************************************************
  2.  
  3.                 Print.c
  4.  
  5.     This file is used whenever a structure must be printed fully.
  6.     Structures that can be printed are Windows, Gadgets, Menus and
  7.     even full Screens!
  8.     This file is supposed to be linked with Basic.o.
  9.  
  10.                     Rick van Rein, October 30, 1990
  11.  
  12. ****************************************************************************/
  13.  
  14.  
  15.  
  16. #include <functions.h>
  17. #include <intuition/intuition.h>
  18. #include <stdio.h>
  19.  
  20. void PrintDrawMode ();
  21. void PrintPen ();
  22. void PrintFlags ();
  23. void PrintStr ();
  24. void mprintf ();        /* Use it like you would use printf. Insert a '\t' for tab to X=49 */
  25.  
  26. extern struct Image *StdCheckMark;    /* Address of default CheckMark as is probably in ROM */
  27.  
  28. #define abs(x) (((x) >= 0)? (x): (-(x)))
  29.  
  30.  
  31. #define INTUITEXT    0
  32. #define BORDER        1
  33. #define BORDERCOORDS    2
  34. #define IMAGE        3
  35. #define IMAGEDATA    4
  36. #define GADGET        5
  37. #define BOOLINFO    6
  38. #define PROPINFO    7
  39. #define STRINGINFO    8
  40. #define STRINGBUF    9
  41. #define STRINGUNDO    10
  42. #define WINDOW        11
  43. #define PROPBUF        12
  44. #define MENU        13
  45. #define MENUITEM    14
  46. #define NEWSCREEN    15
  47. #define COLORMAP    16
  48. #define WINDOWARRAY    17
  49. #define MENUARRAY    18
  50.  
  51.  
  52. extern char *StructNames [];
  53.  
  54. extern int ctr [];
  55.  
  56.  
  57.  
  58. /***** Print a struct IntuiText: */
  59.  
  60. static int PrintIntuiText (itx)        /* Returns number N within label itxN */
  61.    struct IntuiText *itx;
  62.  {
  63.    int me,child;
  64.  
  65.    if (itx->NextText)
  66.       child=PrintIntuiText (itx->NextText);
  67.    mprintf ("\nstruct IntuiText %s%d=\n {\n   ",StructNames [INTUITEXT],me=++ctr [INTUITEXT]);
  68.    PrintPen (itx->FrontPen);
  69.    mprintf (",");
  70.    PrintPen (itx->BackPen);
  71.    mprintf (",\t/* FrontPen, BackPen */\n   ");
  72.    PrintDrawMode (itx->DrawMode);
  73.    mprintf (",\t/* DrawMode */\n   ");
  74.    mprintf ("%d,%d,\t/* LeftEdge, TopEdge */\n   ",itx->LeftEdge,itx->TopEdge);
  75.    mprintf ("NULL,\t/* ITextFont */\n   (UBYTE *) ");
  76.    PrintStr (itx->IText);
  77.    mprintf (",\t/* IText */\n   ");
  78.    if (itx->NextText)
  79.       mprintf ("&%s%d\t/* NextText */\n };\n",StructNames [INTUITEXT],child);
  80.    else
  81.       mprintf ("NULL\t/* NextText */\n };\n");
  82.    return me;
  83.  }
  84.  
  85.  
  86. /***** Print a struct Border: */
  87.  
  88. static int PrintBorder (bor)
  89.    struct Border *bor;
  90.  {
  91.    int child,me,i;
  92.  
  93.    if (bor->NextBorder)
  94.       child=PrintBorder (bor->NextBorder);
  95.    mprintf ("\nSHORT %s%d []=\n",StructNames [BORDERCOORDS],me=++ctr [BORDERCOORDS]);
  96.    for (i=0;i<bor->Count;i++)
  97.       mprintf ("%s\n   %d,%d",i? ",": " {",bor->XY [i+i],bor->XY [i+i+1]);
  98.    mprintf ("\n };\n\nstruct Border %s%d=\n {\n   ",StructNames [BORDER],me);
  99.    mprintf ("%d,%d,\t/* LeftEdge,TopEdge */\n   ",bor->LeftEdge,bor->TopEdge);
  100.    PrintPen (bor->FrontPen);
  101.    mprintf (",");
  102.    PrintPen (bor->BackPen);
  103.    mprintf (",\t/* FrontPen, BackPen */\n   ");
  104.    PrintDrawMode (bor->DrawMode);
  105.    mprintf (",\t/* DrawMode */\n   ");
  106.    mprintf ("%d,\t/* Count */\n   %s%d,\t/* XY */\n   ",bor->Count,StructNames [BORDERCOORDS],me);
  107.    if (bor->NextBorder)
  108.       mprintf ("&%s%d\t/* NextBorder */\n };\n",StructNames [BORDER],child);
  109.    else
  110.       mprintf ("NULL\t/* NextBorder */\n };\n");
  111.    return me;
  112.  }
  113.  
  114.  
  115. /***** Print the data that is needed for an Image; Print anything from the { on: */
  116.  
  117. static void PrintImageData (img)
  118.    struct Image *img;
  119.  {
  120.    int pl,plc,hg,hgc,wd,wdc;
  121.    USHORT *dataptr=img->ImageData;
  122.    UBYTE pick,onoff;
  123.  
  124.    pl=img->Depth;
  125.    wd=(img->Width + 15) >> 4;    /* Make the width a word-counter */
  126.    hg=img->Height;
  127.    onoff=img->PlaneOnOff;
  128.    plc=0;
  129.  
  130.    mprintf (" {\n");
  131.            /* Start printing the planes needed: */
  132.    for (pick=img->PlanePick;pick;pick>>=1)
  133.     {
  134.       if (!(pick & 0x01))
  135.        {
  136.          if (onoff & 0x01)
  137.         mprintf ("                /* Plane %d consists of a filled rectangle */\n",plc);
  138.      else
  139.         mprintf ("                /* Plane %d is not filled anyhow */\n",plc);
  140.        }
  141.       else
  142.        {
  143.          mprintf ("                /* Plane %d contains a picture: */\n",plc);
  144.  
  145.          /* Start printing the lines needed: */
  146.          for (hgc=0;hgc<hg;hgc++)
  147.       {
  148.  
  149.             mprintf ("   ");
  150.             /* Start printing each word in the line: */
  151.         for (wdc=0;wdc<wd;wdc++)
  152.            mprintf ("0x%04x%s",*(dataptr++),((wdc+1<wd) || (hgc+1<hg) || ((pick & 0xfe)!=0))? ",": "");
  153.         mprintf ("\n");
  154.       }
  155.        }
  156.       onoff>>=1;
  157.       plc++;
  158.     }
  159.    mprintf (" };\n");
  160.  }
  161.  
  162.  
  163. /***** Print a struct Image: */
  164.  
  165. static int PrintImage (img)
  166.    struct Image *img;
  167.  {
  168.    int child,me;
  169.  
  170.    if (img->NextImage)
  171.       child=PrintImage (img->NextImage);
  172.    me=++ctr [IMAGE];
  173.  
  174.    if (img->ImageData)
  175.     {
  176.       mprintf ("\nUSHORT %s%d []=\n",StructNames [IMAGEDATA],me);
  177.       PrintImageData (img);
  178.     }
  179.  
  180.    mprintf ("\nstruct Image %s%d=\n {\n   ",StructNames [IMAGE],me);
  181.    mprintf ("%d,%d,\t/* LeftEdge,TopEdge */\n   ",img->LeftEdge,img->TopEdge);
  182.    mprintf ("%d,%d,%d,\t/* Width,Height,Depth */\n   ",img->Width,img->Height,img->Depth);
  183.    
  184.    if (img->ImageData)
  185.       mprintf ("%s%d,\t/* ImageData */\n   ",StructNames [IMAGEDATA],me);
  186.    else
  187.       mprintf ("NULL,\t/* ImageData */\n   ");
  188.  
  189.    mprintf ("0x%02x,0x%02x,\t/* PlanePick,PlaneOnOff */\n   ",img->PlanePick,img->PlaneOnOff);
  190.  
  191.    if (img->NextImage)
  192.       mprintf ("&%s%d\t/* NextImage */\n };\n",StructNames [IMAGE],child);
  193.    else
  194.       mprintf ("NULL\t/* NextImage */\n };\n");
  195.  
  196.    return me;
  197.  }
  198.  
  199.  
  200.  
  201. /***** Print a struct BoolInfo (Yes, it DOES seem to exists!): */
  202.  
  203. static void PrintBoolInfo (bin,me,wd,hg)
  204.    struct BoolInfo *bin;
  205.    int me;
  206.    int wd,hg;
  207.  {
  208.    struct Image img;
  209.  
  210.    if (bin->Flags)
  211.     {
  212.       img.Width=wd;
  213.       img.Height=hg;
  214.       img.Depth=1;
  215.       img.PlaneOnOff=0x01;
  216.       img.PlanePick=0x00;
  217.       img.ImageData=bin->Mask;
  218.       mprintf ("\nUWORD %s%d=\n",StructNames [IMAGEDATA],me);
  219.       PrintImageData (&img);
  220.     }
  221.    mprintf ("\nstruct BoolInfo %s%d=\n {\n   ",StructNames [BOOLINFO],me);
  222.    if (bin->Flags)
  223.       mprintf ("BOOLMASK,\t/* Flags */\n   %s%d,\t/* Mask */\n   ",StructNames [IMAGEDATA],me);
  224.    else
  225.       mprintf ("0,\t/* Flags */\n   NULL,\t/* Mask */\n   ");
  226.    mprintf ("0x%08lx\t/* Reserved */\n };\n",bin->Reserved);
  227.  }
  228.  
  229.  
  230. /***** Print a struct StringInfo: */
  231.  
  232. static void PrintStringInfo (sin,me)
  233.    struct StringInfo *sin;
  234.    int me;
  235.  {
  236.    mprintf ("\nchar %s%d [%d]=",StructNames [STRINGBUF],me,sin->MaxChars);
  237.    PrintStr (sin->Buffer);    /* It should be initialized, shouldn't it? */
  238.    mprintf (";\n\nchar %s%d [%d];\n",StructNames [STRINGUNDO],me,sin->MaxChars);
  239.    mprintf ("\nstruct StringInfo %s%d=\n {\n   ",StructNames [STRINGINFO],me);
  240.    mprintf ("(UBYTE *) %s%d,(UBYTE *) %s%d,\t/* Buffer,UndoBuffer */\n   ",StructNames [STRINGBUF],me,StructNames [STRINGUNDO],me);
  241.    mprintf ("%d,\t/* BufferPos */\n   ",sin->BufferPos);
  242.    mprintf ("%d,\t/* MaxChars */\n   ",sin->MaxChars);
  243.    mprintf ("%d\t/* DispPos */\n",sin->DispPos);
  244.    mprintf ("\t/* Intuition initializes and maintains all other variables for you */\n };\n");
  245.  }
  246.  
  247.  
  248. long PropFlagsFld []=
  249.  { AUTOKNOB, FREEHORIZ, FREEVERT, PROPBORDERLESS, KNOBHIT, 0L };
  250.  
  251. #define PropFlags PropFlagsFld
  252.  
  253. char *PropFlagsNms []=
  254.  { "AUTOKNOB", "FREEHORIZ", "FREEVERT", "PROPBORDERLESS", "KNOBHIT" };
  255.  
  256.  
  257. /***** Print a struct PropInfo: */
  258.  
  259. static void PrintPropInfo (pin,me)
  260.    struct PropInfo *pin;
  261.    int me;
  262.  {
  263.    mprintf ("\nstruct PropInfo %s%d=\n {\n   ",StructNames [PROPINFO],me);
  264.    PrintFlags ((long) pin->Flags,PropFlagsFld,PropFlags,PropFlagsNms);
  265.    mprintf (",\t/* Flags */\n   ");
  266.    mprintf ("%d,%d,\t/* HorizPot,VertPot (%d,%d%%) */\n   ",pin->HorizPot,pin->VertPot,(int) ((100L*pin->HorizPot)>>16),(int) ((100L*pin->VertPot)>>16));
  267.    mprintf ("%d,%d\t/* Horizbody,VertBody */\n",pin->HorizBody,pin->VertBody);
  268.    mprintf ("\t/* The rest are the variables that Intuition sets and maintains */\n };\n");
  269.  }
  270.  
  271.  
  272. long GadgFlagsFld []=
  273.  { GADGHIGHBITS, GADGHIGHBITS, GADGHIGHBITS, GADGHIGHBITS, GADGIMAGE, GRELBOTTOM, GRELRIGHT, GRELWIDTH, GRELHEIGHT, SELECTED, GADGDISABLED, 0L };
  274.  
  275. long GadgFlags []=
  276.  { GADGHCOMP, GADGHBOX, GADGHIMAGE, GADGHNONE, GADGIMAGE, GRELBOTTOM, GRELRIGHT, GRELWIDTH, GRELHEIGHT, SELECTED, GADGDISABLED };
  277.  
  278. char *GadgFlagsNms []=
  279.  { "GADGHCOMP", "GADGHBOX", "GADGHIMAGE", "GADGHNONE", "GADGIMAGE", "GRELBOTTOM", "GRELRIGHT", "GRELWIDTH", "GRELHEIGHT", "SELECTED", "GADGDISABLED" };
  280.  
  281.  
  282. long GadgActivationFld []=
  283.  { RELVERIFY, GADGIMMEDIATE, ENDGADGET, FOLLOWMOUSE, RIGHTBORDER, LEFTBORDER, TOPBORDER, BOTTOMBORDER, TOGGLESELECT, STRINGCENTER, STRINGRIGHT, LONGINT, ALTKEYMAP, BOOLEXTEND, 0L };
  284.  
  285. #define GadgActivation GadgActivationFld
  286.  
  287. char *GadgActivationNms []=
  288.  { "RELVERIFY", "GADGIMMEDIATE", "ENDGADGET", "FOLLOWMOUSE", "RIGHTBORDER", "LEFTBORDER", "TOPBORDER", "BOTTOMBORDER", "TOGGLESELECT", "STRINGCENTER", "STRINGRIGHT", "LONGINT", "ALTKEYMAP", "BOOLEXTEND" };
  289.  
  290.  
  291. long GadgTypesFld []=
  292.  { SYSGADGET, SCRGADGET, GZZGADGET, REQGADGET, 0x00f0, 0x00f0, 0x00f0, 0x00f0, 0x00f0, 0x00f0, 0x00f0, 0x00f0, 0x0007, 0x0007, 0x0007, 0x0007, 0L };
  293.  
  294. long GadgTypes []=
  295.  { SYSGADGET, SCRGADGET, GZZGADGET, REQGADGET, SIZING, WDRAGGING, SDRAGGING, WUPFRONT, SUPFRONT, WDOWNBACK, SDOWNBACK, CLOSE, BOOLGADGET, GADGET0002, PROPGADGET, STRGADGET };
  296.  
  297. char *GadgTypesNms []=
  298.  { "SYSGADGET", "SCRGADGET", "GZZGADGET", "REQGADGET", "SIZING", "WDRAGGING", "SDRAGGING", "WUPFRONT", "SUPFRONT", "WDOWNBACK", "SDOWNBACK", "CLOSE", "BOOLGADGET", "GADGET0002", "PROPGADGET", "STRGADGET" };
  299.  
  300.  
  301. /***** Print a struct Gadget, where "list" is a boolean, telling if we should steal a whole list;
  302.        A returned value of 0 indicates no Gadget has been printed at all: */
  303.  
  304. int PrintGadget (gad,list)
  305.    struct Gadget *gad;
  306.    int list;
  307.  {
  308.    int child,me,itx,gr,sr;
  309.  
  310.    child=0;    /* To cover the case of SYSTEM-gadgets only */
  311.  
  312.    if (gad->NextGadget && list)
  313.       child=PrintGadget (gad->NextGadget,1);
  314.  
  315.    if (list && (gad->GadgetType & SYSGADGET))
  316.       return child;        /* Do not print SystemGadgets in case of listing Gadgets */
  317.  
  318.    me=++ctr [GADGET];
  319.    if (gad->GadgetRender)
  320.       if ((gad->Flags & GADGIMAGE) || (gad->GadgetType & 0x0007)==PROPGADGET)
  321.          if ((gad->GadgetType & 0x0007)==PROPGADGET && ((struct PropInfo *) gad->SpecialInfo)->Flags & AUTOKNOB)
  322.         mprintf ("\nSHORT %s%d [4];\n",StructNames [PROPBUF],me);
  323.      else
  324.             gr=PrintImage ((struct Image *) gad->GadgetRender);
  325.       else
  326.          gr=PrintBorder ((struct Border *) gad->GadgetRender);
  327.    if (gad->SelectRender && (gad->Flags & GADGHIGHBITS)==GADGHBOX)
  328.       sr=PrintBorder ((struct Border *) gad->SelectRender);
  329.    if (gad->SelectRender && (gad->Flags & GADGHIGHBITS)==GADGHIMAGE)
  330.       sr=PrintImage ((struct Image *) gad->SelectRender);
  331.    if (gad->GadgetText)
  332.       itx=PrintIntuiText (gad->GadgetText);
  333.    switch (gad->GadgetType & 0x0007)
  334.     {
  335.       case BOOLGADGET:
  336.          if (gad->SpecialInfo)
  337.         PrintBoolInfo (gad->SpecialInfo,me,gad->Width,gad->Height);
  338.      break;
  339.       case PROPGADGET:
  340.          PrintPropInfo (gad->SpecialInfo,me);
  341.      break;
  342.       case STRGADGET:
  343.          PrintStringInfo (gad->SpecialInfo,me);
  344.     }
  345.  
  346.    mprintf ("\nstruct Gadget %s%d=\n {\n   ",StructNames [GADGET],me);
  347.    if (child)
  348.       mprintf ("&%s%d,\t/* NextGadget */\n   ",StructNames [GADGET],child);
  349.    else
  350.       mprintf ("NULL,\t/* NextGadget */\n   ");
  351.    mprintf ("%d,%d,\t/* LeftEdge,TopEdge */\n   ",gad->LeftEdge,gad->TopEdge);
  352.    mprintf ("%d,%d,\t/* Width,Height */\n   ",gad->Width,gad->Height);
  353.    PrintFlags ((long) gad->Flags,GadgFlagsFld,GadgFlags,GadgFlagsNms);
  354.    mprintf (",\t/* Flags */\n   ");
  355.    PrintFlags ((long) gad->Activation,GadgActivationFld,GadgActivation,GadgActivationNms);
  356.    mprintf (",\t/* Activation */\n   ");
  357.    PrintFlags ((long) gad->GadgetType,GadgTypesFld,GadgTypes,GadgTypesNms);
  358.    mprintf (",\t/* GadgetType */\n   ");
  359.    if (gad->GadgetRender)
  360.       if ((gad->Flags & GADGIMAGE) || (gad->GadgetType & 0x0007)==PROPGADGET)
  361.          if ((gad->GadgetType & 0x0007)==PROPGADGET && ((struct PropInfo *) gad->SpecialInfo)->Flags & AUTOKNOB)
  362.         mprintf ("(APTR) %s%d,\t/* GadgetRender (SHORT [4]) */\n   ",StructNames [PROPBUF],me);
  363.      else
  364.             mprintf ("(APTR) &%s%d,\t/* GadgetRender (Image) */\n   ",StructNames [IMAGE],gr);
  365.       else
  366.          mprintf ("(APTR) &%s%d,\t/* GadgetRender (Border) */\n   ",StructNames [BORDER],gr);
  367.    else
  368.       mprintf ("NULL,\t/* GadgetRender */\n   ");
  369.    if (gad->SelectRender && (gad->Flags & GADGHIGHBITS)==GADGHBOX && gad->GadgetType!=PROPGADGET)
  370.       mprintf ("(APTR) &%s%d,\t/* SelectRender (Border) */\n   ",StructNames [BORDER],sr);
  371.       else if (gad->SelectRender && (gad->Flags & GADGHIGHBITS)==GADGHIMAGE && gad->GadgetType!=PROPGADGET)
  372.          mprintf ("(APTR) &%s%d,\t/* SelectRender (Image) */\n   ",StructNames [IMAGE],sr);
  373.       else
  374.          mprintf ("NULL,\t/* SelectRender */\n   ");
  375.    if (gad->GadgetText)
  376.       mprintf ("&%s%d,\t/* GadgetText */\n   ",StructNames [INTUITEXT],itx);
  377.    else
  378.       mprintf ("NULL,\t/* GadgetText */\n   ");
  379.    mprintf ("0x%08lx,\t/* MutualExclude */\n   ",gad->MutualExclude);
  380.    switch (gad->GadgetType & 0x0007)
  381.     {
  382.       case BOOLGADGET:
  383.      if (gad->SpecialInfo)
  384.             mprintf ("(APTR) &%s%d,\t/* SpecialInfo (Boolinfo) */\n   ",StructNames [BOOLINFO],me);
  385.      else
  386.         mprintf ("NULL,\t/* SpecialInfo (BoolInfo) */\n   ");
  387.          break;
  388.       case PROPGADGET:
  389.          mprintf ("(APTR) &%s%d,\t/* SpecialInfo (PropInfo) */\n   ",StructNames [PROPINFO],me);
  390.          break;
  391.       case STRGADGET:
  392.          mprintf ("(APTR) &%s%d,\t/* SpecialInfo (StringInfo) */\n   ",StructNames [STRINGINFO],me);
  393.          break;
  394.       default:            /* GADGET0002 */
  395.          mprintf ("NULL,\t/* SpecialInfo */\n   ");
  396.     }
  397.    mprintf ("%d,\t/* GadgetID */\n   ",gad->GadgetID);
  398.    mprintf ("0x%08lx\t/* UserData */\n };\n",gad->UserData);
  399.  
  400.    return me;
  401.  }
  402.  
  403.  
  404. long WindowFlagsFld []=
  405.  { WINDOWSIZING, WINDOWDRAG, WINDOWDEPTH, WINDOWCLOSE, SIZEBRIGHT, SIZEBBOTTOM, REFRESHBITS, REFRESHBITS, REFRESHBITS, REFRESHBITS, BACKDROP, REPORTMOUSE, GIMMEZEROZERO, BORDERLESS, ACTIVATE, WINDOWACTIVE,
  406.    INREQUEST, MENUSTATE, RMBTRAP, NOCAREREFRESH, WINDOWREFRESH, WBENCHWINDOW, WINDOWTICKED, 0L };
  407.  
  408. long WindowFlags []=
  409.  { WINDOWSIZING, WINDOWDRAG, WINDOWDEPTH, WINDOWCLOSE, SIZEBRIGHT, SIZEBBOTTOM, SMART_REFRESH, SIMPLE_REFRESH, SUPER_BITMAP, OTHER_REFRESH, BACKDROP, REPORTMOUSE, GIMMEZEROZERO, BORDERLESS, ACTIVATE,
  410.    WINDOWACTIVE, INREQUEST, MENUSTATE, RMBTRAP, NOCAREREFRESH, WINDOWREFRESH, WBENCHWINDOW, WINDOWTICKED };
  411.  
  412. char *WindowFlagsNms []=
  413.  { "WINDOWSIZING", "WINDOWDRAG", "WINDOWDEPTH", "WINDOWCLOSE", "SIZEBRIGHT", "SIZEBBOTTOM", "SMART_REFRESH", "SIMPLE_REFRESH", "SUPER_BITMAP", "OTHER_REFRESH", "BACKDROP", "REPORTMOUSE", "GIMMEZEROZERO",
  414.    "BORDERLESS", "ACTIVATE", "WINDOWACTIVE", "INREQUEST", "MENUSTATE", "RMBTRAP", "NOCAREREFRESH", "WINDOWREFRESH", "WBENCHWINDOW", "WINDOWTICKED" };
  415.  
  416.  
  417. long WindowIDCMPFld []=
  418.  { SIZEVERIFY, NEWSIZE, REFRESHWINDOW, MOUSEBUTTONS, MOUSEMOVE, GADGETDOWN, GADGETUP, REQSET, MENUPICK, CLOSEWINDOW, RAWKEY, REQVERIFY, REQCLEAR, MENUVERIFY, NEWPREFS, DISKINSERTED, DISKREMOVED,
  419.    WBENCHMESSAGE, ACTIVEWINDOW, INACTIVEWINDOW, DELTAMOVE, VANILLAKEY, INTUITICKS, LONELYMESSAGE, 0L };
  420.  
  421. #define WindowIDCMP WindowIDCMPFld
  422.  
  423. char *WindowIDCMPNms []=
  424.  { "SIZEVERIFY", "NEWSIZE", "REFRESHWINDOW", "MOUSEBUTTONS", "MOUSEMOVE", "GADGETDOWN", "GADGETUP", "REQSET", "MENUPICK", "CLOSEWINDOW", "RAWKEY", "REQVERIFY", "REQCLEAR", "MENUVERIFY", "NEWPREFS",
  425.    "DISKINSERTED", "DISKREMOVED", "WBENCHMESSAGE", "ACTIVEWINDOW", "INACTIVEWINDOW", "DELTAMOVE", "VANILLAKEY", "INTUITICKS", "LONELYMESSAGE" };
  426.  
  427.  
  428. /***** Print a Window structure in a special way: Derive a struct NewWindow from it! */
  429.  
  430. int PrintWindow (win,list)
  431.    struct Window *win;
  432.    int list;
  433.  {
  434.    int child,me,gad,chk;
  435.  
  436.    if (win->NextWindow && list)
  437.       child=PrintWindow (win->NextWindow,1);
  438.  
  439.    if (win->FirstGadget)
  440.       gad=PrintGadget (win->FirstGadget,1);        /* Print all Gadgets used by the Window */
  441.    else
  442.       gad=0;                        /* Indicating no gadgets were entered */
  443.  
  444.    if (win->CheckMark!=StdCheckMark)
  445.       chk=PrintImage (win->CheckMark);
  446.  
  447.    mprintf ("\nstruct NewWindow %s%d=\n {\n   ",StructNames [WINDOW],me=++ctr [WINDOW]);
  448.    mprintf ("%d,%d,\t/* LeftEdge,TopEdge */\n   ",win->LeftEdge,win->TopEdge);
  449.    mprintf ("%d,%d,\t/* Width,Height */\n   ",win->Width,win->Height);
  450.    PrintPen (win->DetailPen);
  451.    mprintf (",");
  452.    PrintPen (win->BlockPen);
  453.    mprintf (",\t/* DetailPen,BlockPen */\n   ");
  454.  
  455.    PrintFlags (win->IDCMPFlags,WindowIDCMPFld,WindowIDCMP,WindowIDCMPNms);
  456.    mprintf (",\t/* IDCMPFlags */\n   ");
  457.  
  458.    PrintFlags (win->Flags,WindowFlagsFld,WindowFlags,WindowFlagsNms);
  459.    mprintf (",\t/* Flags */\n   ");
  460.  
  461.    if (gad)
  462.       mprintf ("&%s%d,\t/* FirstGadget */\n   ",StructNames [GADGET],gad);
  463.    else
  464.       mprintf ("NULL,\t/* FirstGadget */\n   ");
  465.    if (win->CheckMark!=StdCheckMark)
  466.       mprintf ("&%s%d,\t/* CheckMark */\n   (UBYTE *) ",StructNames [IMAGE],chk);
  467.    else
  468.       mprintf ("NULL,\t/* CheckMark */\n   (UBYTE *) ");
  469.    PrintStr (win->Title);
  470.    mprintf (",\t/* Title */\n   ");
  471.    mprintf ("NULL,\t/* Screen */\n   ");
  472.  
  473.                                /* BitMaps! ##### */
  474.    mprintf ("NULL,\t/* BitMap */\n   ");
  475.  
  476.    mprintf ("%d,%d,\t/* MinWidth,MinHeight */\n   ",win->MinWidth,win->MinHeight);
  477.    mprintf ("%d,%d,\t/* MaxWidth,MaxHeight */\n   ",win->MaxWidth,win->MaxHeight);
  478.  
  479.    mprintf ("WBENCHSCREEN\t/* Type */\n };\n");
  480.  
  481.    return me;
  482.  }
  483.  
  484.  
  485.  
  486. long MenuItemFlagsFld []=
  487.  { CHECKIT, ITEMTEXT, COMMSEQ, MENUTOGGLE, ITEMENABLED, HIGHFLAGS, HIGHFLAGS, HIGHFLAGS, HIGHFLAGS, CHECKED, ISDRAWN, HIGHITEM, MENUTOGGLED, 0L };
  488.  
  489. long MenuItemFlags []=
  490.  { CHECKIT, ITEMTEXT, COMMSEQ, MENUTOGGLE, ITEMENABLED, HIGHIMAGE, HIGHCOMP, HIGHBOX, HIGHNONE, CHECKED, ISDRAWN, HIGHITEM, MENUTOGGLED };
  491.  
  492. char *MenuItemFlagsNms []=
  493.  { "CHECKIT", "ITEMTEXT", "COMMSEQ", "MENUTOGGLE", "ITEMENABLED", "HIGHIMAGE", "HIGHCOMP", "HIGHBOX", "HIGHNONE", "CHECKED", "ISDRAWN", "HIGHITEM", "MENUTOGGLED" };
  494.  
  495.  
  496. /***** Print a struct MenuItem: */
  497.  
  498. static int PrintMenuItem (mit)
  499.    struct MenuItem *mit;
  500.  {
  501.    int child,sub,me,itf,sf;
  502.  
  503.    if (mit->NextItem)
  504.       child=PrintMenuItem (mit->NextItem);
  505.    if (mit->SubItem)
  506.       sub=PrintMenuItem (mit->SubItem);
  507.  
  508.    if (mit->ItemFill)
  509.       if (mit->Flags & ITEMTEXT)
  510.          itf=PrintIntuiText ((struct IntuiText *) mit->ItemFill);
  511.       else
  512.          itf=PrintImage ((struct Image *) mit->ItemFill);
  513.  
  514.    if (mit->SelectFill && (mit->Flags & HIGHFLAGS)==HIGHIMAGE)
  515.          sf=PrintImage ((struct Image *) mit->ItemFill);
  516.  
  517.    mprintf ("\nstruct MenuItem %s%d=\n {\n   ",StructNames [MENUITEM],me=++ctr [MENUITEM]);
  518.    if (mit->NextItem)
  519.       mprintf ("&%s%d,\t/* NextItem */\n   ",StructNames [MENUITEM],child);
  520.    else
  521.       mprintf ("NULL,\t/* NextItem */\n   ");
  522.    mprintf ("%d,%d,\t/* LeftEdge,TopEdge */\n   ",mit->LeftEdge,mit->TopEdge);
  523.    mprintf ("%d,%d,\t/* Width,Height */\n   ",mit->Width,mit->Height);
  524.  
  525.    PrintFlags ((long) mit->Flags,MenuItemFlagsFld,MenuItemFlags,MenuItemFlagsNms);
  526.    mprintf (",\t/* Flags */\n   ");
  527.    mprintf ("0x%08lx,\t/* MutualExclude */\n   ",mit->MutualExclude);
  528.  
  529.    if (mit->ItemFill)
  530.       if (mit->Flags & ITEMTEXT)
  531.          mprintf ("(APTR) &%s%d,\t/* MenuItem (IntuiText) */\n   ",StructNames [INTUITEXT],itf);
  532.       else
  533.          mprintf ("(APTR) &%s%d,\t/* MenuItem (Image) */\n   ",StructNames [IMAGE],itf);
  534.    else
  535.       mprintf ("NULL,\t/* ItemFill */\n   ");
  536.  
  537.    if (mit->SelectFill && (mit->Flags & HIGHFLAGS)==HIGHIMAGE)
  538.       mprintf ("(APTR) &%s%d,\t/* SelectFill (Image) */\n   ");
  539.    else
  540.       mprintf ("NULL,\t/* SelectFill */\n   ");
  541.  
  542.    if (mit->Flags & COMMSEQ)
  543.       if (mit->Command >= ' ' && mit->Command <= 0x7f)
  544.          mprintf ("(BYTE) '%c',\t/* Command (In use) */\n   ",mit->Command);
  545.       else
  546.          mprintf ("0x%02x,\t/* Command (In use) */\n   ");
  547.    else
  548.       mprintf ("0,\t/* Command (Unused) */\n   ");
  549.  
  550.    if (mit->SubItem)
  551.       mprintf ("&%s%d\t/* SubItem */\n   ",StructNames [MENUITEM],sub);
  552.    else
  553.       mprintf ("NULL\t/* SubItem */\n   ");
  554.  
  555.    mprintf ("\t/* NextSelect will be filled in by Intuition */\n };\n");
  556.  
  557.    return me;
  558.  }
  559.  
  560.  
  561. long MenuFlagsFld []=
  562.  { MENUENABLED, MIDRAWN, 0L };
  563.  
  564. #define MenuFlags MenuFlagsFld
  565.  
  566. char *MenuFlagsNms []=
  567.  { "MENUENABLED", "MIDRAWN" };
  568.  
  569.  
  570. /***** Print a struct Menu: */
  571.  
  572. int PrintMenu (men)
  573.    struct Menu *men;
  574.  {
  575.    int child,me,mit;
  576.  
  577.    if (men->NextMenu)
  578.       child=PrintMenu (men->NextMenu);
  579.  
  580.    if (men->FirstItem)
  581.       mit=PrintMenuItem (men->FirstItem);
  582.  
  583.    mprintf ("\nstruct Menu %s%d=\n {\n   ",StructNames [MENU],me=++ctr [MENU]);
  584.  
  585.    if (men->NextMenu)
  586.       mprintf ("&%s%d,\t/* NextMenu */\n   ",StructNames [MENU],child);
  587.    else
  588.       mprintf ("NULL,\t/* NextMenu */\n   ");
  589.  
  590.    mprintf ("%d,%d,\t/* LeftEdge, TopEdge */\n   ",men->LeftEdge,men->TopEdge);
  591.    mprintf ("%d,%d,\t/* Width,Height */\n   ",men->Width,men->Height);
  592.    PrintFlags ((long) men->Flags,MenuFlagsFld,MenuFlags,MenuFlagsNms);
  593.    mprintf (",\t/* Flags */\n   (BYTE *) ");
  594.    PrintStr (men->MenuName);
  595.    mprintf (",\t/* MenuName */\n   ");
  596.  
  597.    if (men->FirstItem)
  598.       mprintf ("&%s%d\t/* FirstItem */\n",StructNames [MENUITEM],mit);
  599.    else
  600.       mprintf ("NULL\t/* FirstItem */\n");
  601.  
  602.    mprintf ("\t/* The other variables are for internal use only */\n };\n");
  603.  
  604.    return me;
  605.  }
  606.  
  607.  
  608.  
  609. /***** Print the ColorMap that goes with each Screen: */
  610.  
  611. static void PrintColorMap (scr,id)
  612.    struct Screen *scr;
  613.    int id;
  614.  {
  615.    int i,cols;
  616.    char *cont;
  617.    UWORD *colmap;
  618.  
  619.    mprintf ("\nUWORD %s%d []=\t/* In the format xRGB (HEX) */\n    { ",StructNames [COLORMAP],id);
  620.  
  621.    colmap=(UWORD *) scr->ViewPort.ColorMap->ColorTable;
  622.    cols=1 << scr->BitMap.Depth;
  623.    cont="";
  624.    for (i=0;i<cols;i++)
  625.     {
  626.       mprintf ("%s0x%04x",cont,*(colmap++));
  627.       cont=", ";
  628.     }
  629.    mprintf (" };\n");
  630.  }
  631.  
  632.  
  633.  
  634. /***** Print an array containing all struct Windows allocated in the Screen handed;
  635.        This array contains some struct NewWindow *'s, terminated with a NULL: */
  636.  
  637. static void PrintWindowArray (scr,id)
  638.    struct Screen *scr;
  639.    int id;
  640.  {
  641.    int oldwin,newwin,winctr;
  642.  
  643.    oldwin=ctr [WINDOW]+1;
  644.  
  645.    if (scr->FirstWindow)
  646.       newwin=PrintWindow (scr->FirstWindow,1);        /* Print a LIST of windows */
  647.    else
  648.       newwin=0;
  649.  
  650.    mprintf ("\nstruct NewWindow *%s%d []=\n { ",StructNames [WINDOWARRAY],id);
  651.    for (winctr=newwin;winctr>=oldwin;winctr--)
  652.       mprintf ("&%s%d, ",StructNames [WINDOW],winctr);
  653.    mprintf ("NULL };\n");
  654.  }
  655.  
  656.  
  657.  
  658. /***** Do exactly the same as in the last function, but now do not print NewWindow-pointers but
  659.        mention their Menu-bases in exactly the same order; NULL now means an empty Menu too: */
  660.  
  661. static void PrintMenuArray (win,id)
  662.    struct Window *win;
  663.    int id;
  664.  {
  665.                /* This function will call itself recursively.
  666.                when building up the calls, any Menu's are printed.
  667.                Then, the stop-condition is encountered, which means initialization
  668.                of the list to be printed. At last, the stack will be emptied, and
  669.                while this is done, the list is extended more and more. */
  670.    if (win)
  671.     {
  672.       int men;
  673.  
  674.       if (win->MenuStrip)
  675.          PrintMenu (win->MenuStrip);
  676.       men=ctr [MENU];
  677.  
  678.       PrintMenuArray (win->NextWindow,-abs (id));        /* Call recursively */
  679.  
  680.       if (win->MenuStrip)
  681.          mprintf ("&%s%d, ",StructNames [MENU],men);
  682.       else
  683.          mprintf ("NULL, ");
  684.     }
  685.    else                        /* End-condition encountered! */
  686.       mprintf ("\nstruct Menu *%s%d []=\n { ",StructNames [MENUARRAY],abs (id));
  687.    if (id>=0)                    /* Last return? */
  688.       mprintf ("NULL };\n");
  689.  }
  690.  
  691.  
  692.  
  693. long FlagsViewModesFld []=
  694.  { HIRES, LACE, SPRITES, DUALPF, EXTRA_HALFBRITE, HAM, PFBA, GENLOCK_VIDEO, VP_HIDE, 0L };
  695.  
  696. #define FlagsViewModes FlagsViewModesFld
  697.  
  698. char *FlagsViewModesNms []=
  699.  { "HIRES", "LACE", "SPRITES", "DUALPF", "EXTRA_HALFBRITE", "HAM", "PFBA", "GENLOCK_VIDEO", "VP_HIDE", 0L };
  700.  
  701.  
  702. long FlagsScrTypesFld []=
  703.  { SCREENTYPE, SCREENTYPE, CUSTOMBITMAP, SCREENBEHIND, SCREENQUIET, 0L };
  704.  
  705. long FlagsScrTypes []=
  706.  { WBENCHSCREEN, CUSTOMSCREEN, CUSTOMBITMAP, SCREENBEHIND, SCREENQUIET };
  707.  
  708. char *FlagsScrTypesNms []=
  709.  { "WBENCHSCREEN", "CUSTOMSCREEN", "CUSTOMBITMAP", "SCREENBEHIND", "SCREENQUIET" };
  710.  
  711.  
  712.  
  713. /***** Print a struct Screen by creating the corresponding struct NewScreen: */
  714.  
  715. int PrintScreen (scr)
  716.    struct Screen *scr;
  717.  {
  718.    int child,me;
  719.  
  720.    PrintColorMap (scr,me=++ctr [NEWSCREEN]);
  721.    PrintWindowArray (scr,me);
  722.    PrintMenuArray (scr->FirstWindow,me);
  723.  
  724.    mprintf ("\nstruct NewScreen %s%d=\n {\n   ",StructNames [NEWSCREEN],me);
  725.    mprintf ("%d,%d,\t/* LeftEdge,TopEdge */\n   ",scr->LeftEdge,scr->TopEdge);
  726.    mprintf ("%d,%d,%d,\t/* Width,Height,Depth */\n   ",scr->Width,scr->Height,scr->BitMap.Depth);
  727.    mprintf ("%d,%d,\t/* DetailPen,BlockPen */\n   ",scr->DetailPen,scr->BlockPen);
  728.    PrintFlags ((long) scr->ViewPort.Modes,FlagsViewModesFld,FlagsViewModes,FlagsViewModesNms);
  729.    mprintf (",\t/* ViewModes */\n   ");
  730.    PrintFlags ((long) scr->Flags,FlagsScrTypesFld,FlagsScrTypes,FlagsScrTypesNms);
  731.    mprintf (",\t/* Type */\n   ");
  732.    mprintf ("NULL,\t/* Font */\n   ");
  733.    mprintf ("(UBYTE *) ");
  734.    PrintStr (scr->DefaultTitle);
  735.    mprintf (",\t/* DefaultTitle */\n   ");
  736.    mprintf ("NULL,\t/* Gadgets */\n   ");
  737.    mprintf ("NULL\t/* CustomBitMap */\n };\n");
  738.  
  739.    return me;
  740.  }
  741.